home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / net / netRoute.c < prev    next >
C/C++ Source or Header  |  1991-03-16  |  28KB  |  1,012 lines
  1. /* 
  2.  * netRoute.c --
  3.  *
  4.  *    This is the code that maintains a table of routes to
  5.  *    Sprite hosts.  The routes contain the transport level
  6.  *    headers that need to be pre-pended to messages so that
  7.  *    they get to the desired Sprite Host.
  8.  *      Routes are added via a system call or determined dynamically using
  9.  *      Sprite's version of ARP (Address Resolution Protocol).  ARP is
  10.  *      invoked when a call to Net_Output is made with a SpriteID for
  11.  *      which there is no route.  Its use is hidden within Net_Output
  12.  *      should not affect the caller of Net_Output.
  13.  *
  14.  *    Operations on routes are:
  15.  *        Net_InstallRoute - Set the Sprite ID for an ethernet address
  16.  *        Net_AddrToID - Get the Sprite ID for an ethernet address
  17.  *        Net_IDToRoute - Return the route for a Sprite host.
  18.  *    Furthermore, the Test_Stats system call will return a route
  19.  *    to a user program with the NET_GET_ROUTE command.
  20.  *
  21.  * Copyright 1988 Regents of the University of California
  22.  * Permission to use, copy, modify, and distribute this
  23.  * software and its documentation for any purpose and without
  24.  * fee is hereby granted, provided that the above copyright
  25.  * notice appear in all copies.  The University of California
  26.  * makes no representations about the suitability of this
  27.  * software for any purpose.  It is provided "as is" without
  28.  * express or implied warranty.
  29.  *
  30.  */
  31.  
  32. #ifndef lint
  33. static char rcsid[] = "$Header: /sprite/src/kernel/net/RCS/netRoute.c,v 9.8 91/03/15 15:48:23 jhh Exp Locker: mgbaker $ SPRITE (Berkeley)";
  34. #endif
  35.  
  36. #include <sprite.h>
  37. #include <net.h>
  38. #include <netRoute.h>
  39. #include <netInt.h>
  40. #include <netUltraInt.h>
  41. #include <sys.h>
  42. #include <stdlib.h>
  43. #include <timer.h>
  44. #include <sync.h>
  45. #include <proc.h>
  46. #include <rpc.h>
  47. #include <string.h>
  48. #include <vm.h>
  49.  
  50. /*
  51.  * Wildcard address for the Ultranet.  This address matches any address.
  52.  */
  53.  
  54. static Net_UltraTLAddress    wildcardAddress = 
  55.                 {7, NET_ULTRA_TSAP_SIZE};
  56. /*
  57.  * The Route table.
  58.  * The table is indexed by Sprite Host IDs.  Access to
  59.  * the table is synchronized with a MASTER_LOCK to prevent
  60.  * changes from interfering with packet handling.
  61.  */
  62. List_Links    netRouteArray[NET_NUM_SPRITE_HOSTS];
  63. NetHostInfo    netHostInfo[NET_NUM_SPRITE_HOSTS];
  64. int         netNumHosts = NET_NUM_SPRITE_HOSTS;
  65. Sync_Semaphore    netRouteMutex = Sync_SemInitStatic("netRouteMutex");
  66. Sync_Semaphore    netFreeRouteMutex = Sync_SemInitStatic("netFreeRouteMutex");
  67.  
  68. /*
  69.  * Macro to swap the fragOffset field.
  70.  */
  71. #define SWAP_FRAG_OFFSET_HOST_TO_NET(ptr) { \
  72.     unsigned short    *shortPtr; \
  73.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  74.     *shortPtr = Net_HostToNetShort(*shortPtr); \
  75. } 
  76.  
  77. static    void        FillRouteInfo _ARGS_((Net_Route *routePtr,
  78.                     Net_RouteInfo *infoPtr));
  79.  
  80.  
  81. /*
  82.  *----------------------------------------------------------------------
  83.  *
  84.  * Net_RouteInit --
  85.  *
  86.  *      Initialize the broadcast routes.  The rest of the routes are
  87.  *      installed via the netRoute user program.  
  88.  *
  89.  *    This uses malloc, so it should be called after Mem_Init.
  90.  *
  91.  * Results:
  92.  *    None.
  93.  *
  94.  * Side effects:
  95.  *    Initialize the route table and add the broadcast route.
  96.  *
  97.  *----------------------------------------------------------------------
  98.  */
  99. void
  100. Net_RouteInit()
  101. {
  102.     register int i;
  103.     int spriteID;
  104.  
  105.     /*
  106.      * The route table.  An array of routes is kept for directing
  107.      * messages to other machines.  It is indexed by Sprite host ids.
  108.      */
  109.     for (spriteID=0 ; spriteID<netNumHosts ; spriteID++) {
  110.     List_Init(&netRouteArray[spriteID]);
  111.     }
  112.     /*
  113.      * Install the broadcast route(s) so we can do our first broadcast rpcs.
  114.      */
  115.     for (i = 0; i < netNumInterfaces;i++) {
  116.     Net_Interface    *interPtr;
  117.     ReturnStatus    status;
  118.  
  119.     interPtr = netInterfaces[i];
  120.     if (interPtr->flags & NET_IFLAGS_BROADCAST) {
  121.         status = Net_InstallRoute(NET_BROADCAST_HOSTID, 
  122.                 interPtr, &interPtr->broadcastAddress, 
  123.                 NET_PROTO_RAW, "broadcast", "unknown", 
  124.                 (ClientData) 0);
  125.         if (status != SUCCESS) {
  126.         printf(
  127.     "Net_RouteInit: unable to install broadcast route for interface %d\n",
  128.             i);
  129.         }
  130.     }
  131.     }
  132.     return;
  133. }
  134.  
  135. /*
  136.  *----------------------------------------------------------------------
  137.  *
  138.  * Net_InstallRouteStub --    
  139.  *
  140.  *    System call stub for Net_InstallRoute
  141.  *
  142.  * Results:
  143.  *    A return status.
  144.  *
  145.  * Side effects:
  146.  *    See Net_InstallRoute
  147.  *
  148.  *----------------------------------------------------------------------
  149.  */
  150. ReturnStatus
  151. Net_InstallRouteStub(size, routeInfoPtr)
  152.     int          size;
  153.     Net_RouteInfo *routeInfoPtr;    /* Route data */
  154. {
  155.     ReturnStatus     status;
  156.     Net_RouteInfo     routeInfo;
  157.     Net_Interface     *interPtr;
  158.  
  159.     if (routeInfoPtr == USER_NIL) {
  160.     return (SYS_ARG_NOACCESS);
  161.     }
  162.     if (size != sizeof(Net_RouteInfo)) {
  163.     return (GEN_INVALID_ARG);
  164.     }
  165.     status = Vm_CopyIn(sizeof(Net_RouteInfo), (Address)routeInfoPtr, 
  166.               (Address)&routeInfo);
  167.     if (status != SUCCESS) {
  168.     return(status);
  169.     }
  170.     if (routeInfo.version != NET_ROUTE_VERSION) {
  171.     return GEN_INVALID_ARG;
  172.     }
  173.     if (routeInfo.interface < 0 || routeInfo.interface >= netNumInterfaces) {
  174.     printf("Net_InstallRouteStub: interface %d does not exist\n",
  175.         routeInfo.interface);
  176.     return(GEN_INVALID_ARG);
  177.     }
  178.     interPtr = Net_GetInterface(routeInfo.netType, routeInfo.interface);
  179.     if (interPtr == (Net_Interface *) NIL) {
  180.     printf("Net_InstallRouteStub: can't find interface %d\n",
  181.         routeInfo.interface);
  182.     return(GEN_INVALID_ARG);
  183.     }
  184.     status = Net_InstallRoute(routeInfo.spriteID,
  185.             interPtr, routeInfo.netAddress, 
  186.             routeInfo.protocol,
  187.             routeInfo.hostname, routeInfo.machType, 
  188.             routeInfo.userData);
  189.     return(status);
  190. }
  191.  
  192. /*
  193.  *----------------------------------------------------------------------
  194.  *
  195.  * Net_InstallRoute --
  196.  *
  197.  *    Install a route to a Sprite host at the specified address.
  198.  *    After installing the route the Sprite ID can be used as an
  199.  *    argument to Rpc_Call to direct an RPC request to that Sprite host.
  200.  *
  201.  * Results:
  202.  *    None.
  203.  *
  204.  * Side effects:
  205.  *    Initialize the entry in the route table which is indexed
  206.  *    by the Sprite ID to point to a route for the Sprite Host.
  207.  *
  208.  *----------------------------------------------------------------------
  209.  */
  210.  
  211. ReturnStatus
  212. Net_InstallRoute(spriteID, interPtr, netAddressPtr, protocol, 
  213.     hostname, machType, clientData)
  214.     int         spriteID;    /* Sprite Host ID */
  215.     Net_Interface    *interPtr;    /* Interface route is for. */
  216.     Net_Address     *netAddressPtr;    /* Network addresses (indexed by
  217.                      * protocol). */
  218.     int            protocol;    /* Protocol to use with route. */
  219.     char         *hostname;    /* Human recognizable name */
  220.     char         *machType;      /* Machine type to expand $MACHINE */
  221.     ClientData        clientData;     /* Data for user-level program. */
  222. {
  223.     register Net_Route     *routePtr;
  224.     Net_Route        *oldRoutePtr;
  225.     ReturnStatus status = SUCCESS;
  226.     char    *headerPtr;
  227.  
  228.     if (Mach_AtInterruptLevel()) {
  229.     printf("Can't install route when at interrupt level (%d)\n",
  230.         spriteID);
  231.     return FAILURE;
  232.     }
  233.     if (spriteID < 0) {
  234.     printf("Invalid sprite id %d\n", spriteID);
  235.     return (GEN_INVALID_ARG);
  236.     }
  237.     /*
  238.      * If we are installing a route and we don't know are own spriteID see
  239.      * if we can learn it from the route.
  240.      */
  241.     if (rpc_SpriteID == 0) {
  242.     if (!NET_ADDRESS_COMPARE(interPtr->netAddress[protocol],
  243.         netAddressPtr[protocol])) {
  244.         rpc_SpriteID = spriteID;
  245.     }
  246.     }
  247.     /*
  248.      * If we know our spriteID and we are installing a route to ourselves we
  249.      * can learn (or at least validate our data).
  250.      */
  251.     if ((rpc_SpriteID > 0) && (rpc_SpriteID == spriteID)) {
  252.     char buffer[128];
  253.  
  254.     if (!(NET_ADDRESS_COMPARE(interPtr->netAddress[protocol],
  255.         netZeroAddress))) {
  256.         interPtr->netAddress[protocol] = netAddressPtr[protocol];
  257.         Net_AddrToString(&interPtr->netAddress[protocol], protocol, 
  258.             interPtr->netType, buffer);
  259.         printf("Setting address to %s\n", buffer);
  260.     } else if (NET_ADDRESS_COMPARE(interPtr->netAddress[protocol], 
  261.             netAddressPtr[protocol])) {
  262.         Net_AddrToString(&interPtr->netAddress[protocol], protocol, 
  263.         interPtr->netType, buffer);
  264.         printf(
  265.         "Warning: address on interface \"%s\" is currently %s\n",
  266.         interPtr->name,
  267.         buffer);
  268.         Net_AddrToString(&netAddressPtr[protocol], protocol, 
  269.         interPtr->netType, buffer);
  270.         printf("Attempt to install route using address %s ignored.\n",
  271.         buffer);
  272.         status = FAILURE;
  273.     }
  274.     return status;
  275.     }
  276.     routePtr = (Net_Route *) malloc(sizeof(Net_Route));
  277.     MASTER_LOCK(&netRouteMutex);
  278.  
  279.     /*
  280.      * In order to install internet routes our internet address must be set.
  281.      */
  282.     if ((protocol == NET_PROTO_INET) && 
  283.     (interPtr->netAddress[protocol].inet == netZeroAddress.inet)) {
  284.  
  285.     Boolean     found = FALSE;
  286.     int        addr;
  287.     Net_Route    *tmpPtr;
  288.     /*
  289.      * Try to do a reverse arp to get the internet address.  
  290.      */
  291.     LIST_FORALL(&netRouteArray[NET_BROADCAST_HOSTID], 
  292.         (List_Links *) tmpPtr){
  293.  
  294.         if (tmpPtr->interPtr == interPtr) {
  295.         found = TRUE;
  296.         break;
  297.         }
  298.     }
  299.     if (!found) {
  300.         printf("Can't find broadcast route for interface %s\n",
  301.         interPtr->name);
  302.         MASTER_UNLOCK(&netRouteMutex);
  303.         return FAILURE;
  304.     }
  305.     addr = Net_RevArp(tmpPtr, protocol, (Net_Address *) NIL, 
  306.             &netRouteMutex);
  307.     if (addr == -1) {
  308.         printf("Internet address for interface \"%s\" is not set and\n",
  309.         interPtr->name);
  310.         printf("reverse arp failed.  Can't install route.\n");
  311.         MASTER_UNLOCK(&netRouteMutex);
  312.         return FAILURE;
  313.     }
  314.     interPtr->netAddress[protocol].inet = addr;
  315.     }
  316.     if (spriteID >= NET_NUM_SPRITE_HOSTS) {
  317.     printf("Net route table too small!\n");
  318.     MASTER_UNLOCK(&netRouteMutex);
  319.     return FAILURE;
  320.     } else {
  321.     Net_Route     *tmpPtr;
  322.     oldRoutePtr = (Net_Route *)NIL;
  323.     LIST_FORALL(&netRouteArray[spriteID], (List_Links *) tmpPtr) {
  324.         if ((tmpPtr->interPtr == interPtr) &&
  325.         (tmpPtr->protocol == protocol)) {
  326.  
  327.         tmpPtr->flags &= ~NET_RFLAGS_VALID;
  328.         oldRoutePtr = tmpPtr;
  329.         break;
  330.         }
  331.     }
  332.     List_InitElement((List_Links *) routePtr);
  333.     List_Insert((List_Links *) routePtr, 
  334.         LIST_ATREAR((List_Links *) &netRouteArray[spriteID]));
  335.     (void) strncpy(netHostInfo[spriteID].name, hostname, 20);
  336.     (void) strncpy(netHostInfo[spriteID].machType, machType, 12);
  337.  
  338.     routePtr->flags = NET_RFLAGS_VALID;
  339.     routePtr->refCount = 0;
  340.     routePtr->spriteID = spriteID;
  341.     routePtr->interPtr = interPtr;
  342.     routePtr->maxBytes = interPtr->maxBytes;
  343.     routePtr->minBytes = interPtr->minBytes;
  344.     routePtr->protocol = protocol;
  345.     routePtr->routeID |= spriteID << 16;
  346.     routePtr->userData = clientData;
  347.     sprintf(routePtr->desc, "Route to %s - ", hostname);
  348.     }
  349.     /*
  350.      * Prepare the Route.  This includes the transport header that
  351.      * will be used in messages sent to the Sprite Host.
  352.      */
  353.     headerPtr = (char *) routePtr->buffer;
  354.     switch(interPtr->netType) {
  355.     case NET_NETWORK_ETHER: {
  356.         Net_EtherHdr *etherHdrPtr;
  357.         strcat(routePtr->desc, "ethernet, ");
  358.         /*
  359.          * Fill in an ethernet header for the route.
  360.          * The drivers fill in the source part of the ethernet header 
  361.          * each time they send out a packet.
  362.          */
  363.         if (oldRoutePtr != (Net_Route *) NIL) {
  364.         etherHdrPtr = (Net_EtherHdr *)oldRoutePtr->headerPtr;
  365.         if (NET_ETHER_COMPARE(
  366.             NET_ETHER_HDR_DESTINATION(*etherHdrPtr),
  367.             netAddressPtr[NET_PROTO_RAW].ether)) {
  368.             printf(
  369.         "Warning: Net_InstallRoute, host <%d> changing ethernet addr\n",
  370.                 spriteID);
  371.         }
  372.         }
  373.         if (protocol == NET_PROTO_RAW) {
  374.         etherHdrPtr = (Net_EtherHdr *)routePtr->buffer;
  375.         NET_ETHER_HDR_TYPE(*etherHdrPtr) = 
  376.             Net_HostToNetShort(NET_ETHER_SPRITE);
  377.         } else {
  378.         /*
  379.          * Make the ethernet header start on an odd 16 bit boundary so
  380.          * that the (internet) header that follows starts on a
  381.          * 32 bit boundary.
  382.          */
  383.         etherHdrPtr = (Net_EtherHdr *)
  384.             ((((int) routePtr->buffer + 5) & ~0x3) - 2);
  385.         NET_ETHER_HDR_TYPE(*etherHdrPtr) = 
  386.                     Net_HostToNetShort(NET_ETHER_IP);
  387.         }
  388.         routePtr->headerPtr[NET_PROTO_RAW] = (Address)etherHdrPtr;
  389.         NET_ETHER_ADDR_COPY(netAddressPtr[NET_PROTO_RAW].ether,
  390.                 NET_ETHER_HDR_DESTINATION(*etherHdrPtr));
  391.         NET_ETHER_ADDR_COPY(interPtr->netAddress[NET_PROTO_RAW].ether,
  392.                 NET_ETHER_HDR_SOURCE(*etherHdrPtr));
  393.         routePtr->netAddress[NET_PROTO_RAW].ether = 
  394.         netAddressPtr[NET_PROTO_RAW].ether;
  395.         headerPtr = (char *) etherHdrPtr;
  396.         break;
  397.     }
  398.     case NET_NETWORK_ULTRA: {
  399.         Net_UltraHeader    *ultraHdrPtr;
  400.  
  401.         ultraHdrPtr = (Net_UltraHeader *) routePtr->buffer;
  402.         bzero((char *) ultraHdrPtr, sizeof(Net_UltraHeader));
  403.         strcat(routePtr->desc, "ultranet, ");
  404.         routePtr->headerPtr[NET_PROTO_RAW] = (Address) ultraHdrPtr;
  405.         ultraHdrPtr->remoteAddress = wildcardAddress;
  406.         ultraHdrPtr->remoteAddress.tsapSize=2;
  407.         ultraHdrPtr->remoteAddress.tsap[0]=0xff;
  408.         ultraHdrPtr->remoteAddress.tsap[1]=0xff;
  409.         ultraHdrPtr->remoteAddress.address = 
  410.         netAddressPtr[NET_PROTO_RAW].ultra;
  411.         ultraHdrPtr->localAddress = wildcardAddress;
  412.         ultraHdrPtr->localAddress.tsapSize=2;
  413.         ultraHdrPtr->localAddress.tsap[0]=0xff;
  414.         ultraHdrPtr->localAddress.tsap[1]=0xff;
  415.         ultraHdrPtr->localAddress.address = 
  416.         interPtr->netAddress[NET_PROTO_RAW].ultra;
  417.         ultraHdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  418.         headerPtr = (char *) ultraHdrPtr;
  419.         routePtr->netAddress[NET_PROTO_RAW].ultra = 
  420.         netAddressPtr[NET_PROTO_RAW].ultra;
  421.         break;
  422.     }
  423.     default:
  424.         printf("Net_InstallRoute: Unknown interface type %d\n", 
  425.         interPtr->netType);
  426.         return FAILURE;
  427.     }
  428.     headerPtr += net_NetworkHeaderSize[interPtr->netType];
  429.     switch (protocol) {
  430.     case NET_PROTO_RAW:
  431.         strcat(routePtr->desc, "raw");
  432.         break;
  433.     case NET_PROTO_INET: {
  434.         Net_IPHeader *ipHeader;
  435.         strcat(routePtr->desc, "IP");
  436.         ipHeader = (Net_IPHeader *) headerPtr;
  437.         routePtr->headerPtr[protocol] = (Address)ipHeader;
  438.         /*
  439.          * Initialize the template ipHeader.
  440.          */
  441.         bzero((char *)ipHeader, sizeof(Net_IPHeader));
  442.         ipHeader->headerLen = sizeof(Net_IPHeader) / 4;
  443.         ipHeader->version = NET_IP_VERSION;
  444.         ipHeader->typeOfService = 0;
  445.         /*
  446.          * Kernel IP doesn't handle fragmented IP packets (yet).
  447.          */
  448.         ipHeader->flags = NET_IP_DONT_FRAG;
  449.         SWAP_FRAG_OFFSET_HOST_TO_NET(ipHeader);
  450.         ipHeader->timeToLive = NET_IP_MAX_TTL;
  451.         ipHeader->protocol = NET_IP_PROTOCOL_SPRITE;
  452.         ipHeader->source = interPtr->netAddress[protocol].inet;
  453.         ipHeader->dest = netAddressPtr[NET_PROTO_INET].inet;
  454.         /*
  455.          * Precompute the checksum for the ipHeader. This must be
  456.          * corrected when the totalLen field is updated. Note we
  457.          * store the checksum as the 16 bit sum of the packet
  458.          * header to permit easy updating.
  459.          */
  460.         ipHeader->checksum = Net_InetChecksum(sizeof(Net_IPHeader),
  461.                            (Address) ipHeader);
  462.         ipHeader->checksum = ~ipHeader->checksum;
  463.         routePtr->maxBytes -= sizeof(Net_IPHeader);
  464.         routePtr->minBytes -= sizeof(Net_IPHeader);
  465.         if (routePtr->minBytes < 0) {
  466.         routePtr->minBytes = 0;
  467.         }
  468.         routePtr->netAddress[NET_PROTO_INET].inet = 
  469.         netAddressPtr[NET_PROTO_INET].inet;
  470.         break;
  471.     }
  472.     default: {
  473.         if (oldRoutePtr != (Net_Route *) NIL) {
  474.         oldRoutePtr->flags |= NET_RFLAGS_VALID;
  475.         }
  476.         routePtr->flags &= ~NET_RFLAGS_VALID;
  477.         oldRoutePtr = routePtr;
  478.         printf("Warning: Unsupported route type in Net_InstallRoute\n");
  479.         break;
  480.     }
  481.     }
  482.     MASTER_UNLOCK(&netRouteMutex);
  483.     if (oldRoutePtr != (Net_Route *) NIL) {
  484.     Net_DeleteRoute(oldRoutePtr);
  485.     }
  486.     return(SUCCESS);
  487. }
  488.  
  489. /*
  490.  *----------------------------------------------------------------------
  491.  *
  492.  * Net_ReleaseRoute --
  493.  *
  494.  *    Releases a route by decrementing its reference count.
  495.  *
  496.  * Results:
  497.  *    None.
  498.  *
  499.  * Side effects:
  500.  *    The route if freed if it is invalid and the reference count is zero.
  501.  *
  502.  *----------------------------------------------------------------------
  503.  */
  504.  
  505. void
  506. Net_ReleaseRoute(routePtr)
  507.     Net_Route     *routePtr;
  508. {
  509.     Boolean     freeIt = FALSE;
  510.     MASTER_LOCK(&netRouteMutex);
  511.     routePtr->refCount--;
  512.     if (Mach_AtInterruptLevel()) {
  513.     goto exit;
  514.     }
  515.     if ((!(routePtr->flags & NET_RFLAGS_VALID)) && 
  516.     (routePtr->refCount <= 0) &&
  517.     (!(routePtr->flags & NET_RFLAGS_DELETING))) {
  518.     routePtr->flags |= NET_RFLAGS_DELETING;
  519.     freeIt = TRUE;
  520.     }
  521. exit:
  522.     MASTER_UNLOCK(&netRouteMutex);
  523.     if (freeIt) {
  524.     List_Remove((List_Links *) routePtr);
  525.     free((char *) routePtr);
  526.     }
  527. }
  528.  
  529. /*
  530.  *----------------------------------------------------------------------
  531.  *
  532.  * Net_DeleteRoute --
  533.  *
  534.  *    Deletes a route.
  535.  *
  536.  * Results:
  537.  *    None.
  538.  *
  539.  * Side effects:
  540.  *    The route is marked as invalid if it has a positive reference
  541.  *    count, otherwise it is deleted.
  542.  *
  543.  *----------------------------------------------------------------------
  544.  */
  545.  
  546. void
  547. Net_DeleteRoute(routePtr)
  548.     Net_Route    *routePtr;
  549. {
  550.     Boolean     freeIt = FALSE;
  551.     MASTER_LOCK(&netRouteMutex);
  552.     routePtr->flags &= ~NET_RFLAGS_VALID;
  553.     if (Mach_AtInterruptLevel()) {
  554.     goto exit;
  555.     }
  556.     if ((routePtr->refCount <= 0) && 
  557.     (!(routePtr->flags & NET_RFLAGS_DELETING))) {
  558.     routePtr->flags |= NET_RFLAGS_DELETING;
  559.     freeIt = TRUE;
  560.     }
  561. exit:
  562.     MASTER_UNLOCK(&netRouteMutex);
  563.     if (freeIt) {
  564.     List_Remove((List_Links *) routePtr);
  565.     free((char *) routePtr);
  566.     }
  567. }
  568.  
  569. /*
  570.  *----------------------------------------------------------------------
  571.  *
  572.  * Net_IDToRouteStub --
  573.  *
  574.  *    Stub for the Test_Stats system call, NET_GET_ROUTE command.
  575.  *    This gets a route and copies it out to user space.
  576.  *
  577.  * Results:
  578.  *    A return status.
  579.  *
  580.  * Side effects:
  581.  *    Copies to user space.
  582.  *
  583.  *----------------------------------------------------------------------
  584.  */
  585. ReturnStatus
  586. Net_IDToRouteStub(spriteID, size, argPtr)
  587.     int spriteID;        /* option parameter to Test_Stats */
  588.     int    size;            /* Size of user buffer. */
  589.     Address argPtr;        /* User space buffer to hold route */
  590.  
  591. {
  592. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  593.  
  594.     ReturnStatus status;
  595.     Net_Route *routePtr;
  596.     Net_RouteInfo routeInfo;
  597.     int toCopy;
  598.  
  599.     if (spriteID < 0 || spriteID >= netNumHosts) {
  600.     return(SYS_INVALID_ARG);
  601.     }
  602.     routePtr = Net_IDToRoute(spriteID, 0, FALSE, (Sync_Semaphore *) NIL, 0);
  603.     if (routePtr == (Net_Route *)NIL) {
  604.     routeInfo.version = NET_ROUTE_VERSION;
  605.     routeInfo.flags = 0;
  606.     } else {
  607.     FillRouteInfo(routePtr, &routeInfo);
  608.     }
  609.     toCopy = MIN(size, sizeof(Net_RouteInfo) - sizeof(Net_Header));
  610.     status = Vm_CopyOut(toCopy, (Address)&routeInfo, argPtr);
  611.     if (routePtr == (Net_Route *) NIL) {
  612.     return status;
  613.     }
  614.     if (status == SUCCESS) {
  615.     argPtr += toCopy;
  616.     size -= toCopy;
  617.     toCopy = MIN(size, net_NetworkHeaderSize[routePtr->interPtr->netType]);
  618.     status = Vm_CopyOut(toCopy, 
  619.             (Address)routePtr->headerPtr[NET_PROTO_RAW], 
  620.             argPtr);
  621.     argPtr += toCopy;
  622.     size -= toCopy;
  623.     switch(routePtr->protocol) {
  624.         case NET_PROTO_INET:
  625.         toCopy = MIN(size, sizeof(Net_IPHeader));
  626.         status = Vm_CopyOut(sizeof(Net_IPHeader), 
  627.                  (Address)routePtr->headerPtr[NET_PROTO_INET],
  628.                  argPtr);
  629.         argPtr += toCopy;
  630.         size -= toCopy;
  631.         break;
  632.         default:
  633.         break;
  634.     }
  635.     }
  636.     Net_ReleaseRoute(routePtr);
  637.     return(status);
  638. }
  639.  
  640. /*
  641.  *----------------------------------------------------------------------
  642.  *
  643.  * Net_IDToRoute --
  644.  *
  645.  *    Return the route to the host specified by the input sprite id.
  646.  *
  647.  * Results:
  648.  *    A pointer to the route for the host.
  649.  *
  650.  * Side effects:
  651.  *    None.
  652.  *
  653.  *----------------------------------------------------------------------
  654.  */
  655. /*ARGSUSED*/
  656. Net_Route *
  657. Net_IDToRoute(spriteID, index, doArp, mutexPtr, size)
  658.     int     spriteID;    /* Sprite id to find route for. */
  659.     int     index;        /* Which route of many. */
  660.     Boolean    doArp;        /* Do an arp to find a route? */
  661.     Sync_Semaphore *mutexPtr;    /* Mutex to release when doing arp. */
  662.     int     size;        /* Size of data to send (not used yet). */
  663. {
  664.     Net_Route     *routePtr = (Net_Route *) NIL;
  665.     register    Net_Route *tmpPtr;
  666.     int            i;
  667.     ReturnStatus    status;
  668.  
  669.     if (spriteID >= 0 && spriteID < netNumHosts) {
  670.     while (1) {
  671.         i = 0;
  672.         MASTER_LOCK(&netRouteMutex);
  673.         LIST_FORALL(&netRouteArray[spriteID],(List_Links *) tmpPtr) {
  674.         if (tmpPtr->flags & NET_RFLAGS_VALID) {
  675.             if (index >= 0 && i == index) {
  676.             tmpPtr->refCount++;
  677.             routePtr = tmpPtr;
  678.             break;
  679.             } 
  680.             i++;
  681.         }
  682.         }
  683.         MASTER_UNLOCK(&netRouteMutex);
  684.         if (routePtr == (Net_Route *) NIL && doArp) {
  685.         status = Net_Arp(spriteID, mutexPtr);
  686.         if (status != SUCCESS) {
  687.             break;
  688.         }
  689.         doArp = FALSE;
  690.         } else {
  691.         break;
  692.         }
  693.     }
  694.     }
  695.     return(routePtr);
  696. }
  697.  
  698. /*
  699.  *----------------------------------------------------------------------
  700.  *
  701.  * Net_AddrToID --
  702.  *
  703.  *      Determine the Sprite host ID from a physical address.  This is
  704.  *      used by a server, or Reverse Arp, to determine a client's Sprite
  705.  *      ID from the client's network address.
  706.  *
  707.  *      This routine scans the route table looking for an address
  708.  *      match with the input address.  
  709.  *
  710.  * Results:
  711.  *      A Sprite hostid for the host at the address.  If the physical
  712.  *      address isn't in the table we return a hostid of -1.
  713.  *
  714.  * Side effects:
  715.  *    None.
  716.  *
  717.  *----------------------------------------------------------------------
  718.  */
  719. int
  720. Net_AddrToID(netType, protocol, addressPtr)
  721.     Net_NetworkType netType;
  722.     int        protocol;
  723.     Net_Address    *addressPtr;        /* Physical address */
  724. {
  725.     register Net_Route     *routePtr;
  726.     register int     i;
  727.     register int     ID = -1;
  728.  
  729.     MASTER_LOCK(&netRouteMutex);
  730.  
  731.     for (i=0 ; i<netNumHosts ; i++) {
  732.     LIST_FORALL(&netRouteArray[i],(List_Links *) routePtr) {
  733.         if ((routePtr->protocol == protocol) &&
  734.         (routePtr->interPtr->netType == netType) &&
  735.         (!NET_ADDRESS_COMPARE(routePtr->netAddress[protocol], 
  736.             *addressPtr))) {
  737.         ID = routePtr->spriteID;
  738.         break;
  739.         }
  740.     }
  741.     }
  742.     MASTER_UNLOCK(&netRouteMutex);
  743.     return(ID);
  744. }
  745.  
  746. /*
  747.  *----------------------------------------------------------------------
  748.  *
  749.  * Net_HdrToID --
  750.  *
  751.  *      Determine the Sprite host ID from a transport header.  This is
  752.  *      used by a server to determine a client's Sprite
  753.  *      ID from the transport header.
  754.  *
  755.  *      This routine scans the route table looking for an address
  756.  *      match with the input address.  If the flags field of the route
  757.  *      specifies that the address is a broadcast address, this will
  758.  *      return the correct hostid to use for a broadcast.
  759.  *
  760.  * Results:
  761.  *      A Sprite hostid for the host at the address.  If the physical
  762.  *      address isn't in the table we return a hostid of -1.
  763.  *
  764.  * Side effects:
  765.  *    None.
  766.  *
  767.  *----------------------------------------------------------------------
  768.  */
  769. int
  770. Net_HdrToID(netType, protocol, headerPtr)
  771.     Net_NetworkType    netType;
  772.     int            protocol;
  773.     Address headerPtr;    /* Transport header. */
  774. {
  775.     Address         offsetPtr;
  776.     Net_Address     netAddress;
  777.  
  778.     bzero((char *) &netAddress, sizeof(Net_Address));
  779.     if (protocol == NET_PROTO_RAW) {
  780.     switch(netType) {
  781.         case NET_NETWORK_ETHER: {
  782.         NET_ETHER_ADDR_COPY(
  783.             NET_ETHER_HDR_SOURCE(*((Net_EtherHdr *) headerPtr)), 
  784.             netAddress.ether);
  785.         break;
  786.         }
  787.         case NET_NETWORK_ULTRA: {
  788.         netAddress.ultra = 
  789.             ((Net_UltraHeader *) headerPtr)->remoteAddress.address;
  790.         break;
  791.         }
  792.         default:
  793.         printf("Net_HdrToID: unknown netType %d\n", netType);
  794.         return -1;
  795.     }
  796.     } else {
  797.     offsetPtr = headerPtr + net_NetworkHeaderSize[netType];
  798.     switch(protocol) {
  799.         case NET_PROTO_INET : {
  800.         netAddress.inet = 
  801.             Net_NetToHostInt(((Net_IPHeader *) offsetPtr)->dest);
  802.         break;
  803.         }
  804.         default:
  805.         printf("Net_HdrToID: unknown protocol %d\n", protocol);
  806.         return -1;
  807.     }
  808.     }
  809.     return Net_AddrToID(netType, protocol, &netAddress);
  810. }
  811.  
  812.  
  813. /*
  814.  *----------------------------------------------------------------------
  815.  *
  816.  * Net_HdrDestString --
  817.  *
  818.  *    Build a printable message of the destination address from a 
  819.  *    transport header.
  820.  *
  821.  *
  822.  * Results:
  823.  *    None.
  824.  *
  825.  * Side effects:
  826.  *    None.
  827.  *
  828.  *----------------------------------------------------------------------
  829.  */
  830. void
  831. Net_HdrDestString(netType, protocol, headerPtr, bufferLen, buffer)
  832.     Net_NetworkType    netType;
  833.     int            protocol;
  834.     Address headerPtr;    /* Transport header. */
  835.     int    bufferLen;    /* Length of buffer. */
  836.     char *buffer;    /* Destination memory for destination string. */
  837.  
  838. {
  839.     Address         offsetPtr;
  840.     Net_Address     netAddress;
  841.     static char        tmpBuffer[128];
  842.  
  843.     *buffer = '\0';
  844.     if (protocol == NET_PROTO_RAW) {
  845.     switch(netType) {
  846.         case NET_NETWORK_ETHER: {
  847.         NET_ETHER_ADDR_COPY(
  848.             NET_ETHER_HDR_SOURCE(*((Net_EtherHdr *) headerPtr)), 
  849.             netAddress.ether);
  850.         break;
  851.         }
  852.         case NET_NETWORK_ULTRA: {
  853.         netAddress.ultra = 
  854.             ((Net_UltraHeader *) headerPtr)->remoteAddress.address;
  855.         break;
  856.         }
  857.         default:
  858.         printf("Net_HdrDestString: unknown netType %d\n", netType);
  859.         return;
  860.     }
  861.     } else {
  862.     offsetPtr = headerPtr + net_NetworkHeaderSize[netType];
  863.     switch(protocol) {
  864.         case NET_PROTO_INET : {
  865.         netAddress.inet = 
  866.             Net_NetToHostInt(((Net_IPHeader *) offsetPtr)->dest);
  867.         break;
  868.         }
  869.         default:
  870.         printf("Net_HdrDestString: unknown protocol %d\n", protocol);
  871.         return;
  872.     }
  873.     }
  874.     Net_AddrToString(&netAddress, netType, protocol, tmpBuffer);
  875.     (void) strncpy(buffer, tmpBuffer, bufferLen-1);
  876.     return;
  877. }
  878.  
  879.  
  880. /*
  881.  *----------------------------------------------------------------------------
  882.  *
  883.  * Net_SpriteIDToName --
  884.  *
  885.  *    Map from a Sprite ID to a host name.
  886.  *
  887.  * Results:
  888.  *      None.
  889.  *
  890.  * Side effects:
  891.  *      None.
  892.  *
  893.  *----------------------------------------------------------------------------
  894.  */
  895.  
  896. void
  897. Net_SpriteIDToName(spriteID, bufferLen, buffer)
  898.     int     spriteID;
  899.     int        bufferLen;
  900.     char     *buffer;
  901. {
  902.     *buffer = '\0';
  903.     MASTER_LOCK(&netRouteMutex);
  904.     if (spriteID >= 0 && spriteID < netNumHosts) {
  905.     (void) strncpy(buffer, netHostInfo[spriteID].name, bufferLen-1);
  906.     }
  907.     MASTER_UNLOCK(&netRouteMutex);
  908.     return;
  909. }
  910.  
  911. /*
  912.  *----------------------------------------------------------------------------
  913.  *
  914.  * Net_SpriteIDToMachType --
  915.  *
  916.  *    Map from a Sprite ID to a machine type string.  This string is
  917.  *    used by the filesystem when expanding $MACHINE in pathnames.
  918.  *
  919.  * Results:
  920.  *      A pointer to a string identifying the machine type, i.e. "sun3".
  921.  *
  922.  * Side effects:
  923.  *      None.
  924.  *
  925.  *----------------------------------------------------------------------------
  926.  */
  927.  
  928. void
  929. Net_SpriteIDToMachType(spriteID, bufferLen, buffer)
  930.     int     spriteID;
  931.     int        bufferLen;
  932.     char    *buffer;
  933. {
  934.     *buffer = '\0';
  935.     MASTER_LOCK(&netRouteMutex);
  936.     if (spriteID >= 0 && spriteID < netNumHosts) {
  937.     (void) strncpy(buffer, netHostInfo[spriteID].machType, bufferLen-1);
  938.     }
  939.     MASTER_UNLOCK(&netRouteMutex);
  940.     return;
  941. }
  942.  
  943. /*
  944.  *----------------------------------------------------------------------
  945.  *
  946.  * Net_HostPrint --
  947.  *
  948.  *    Print out a statement concerning a host.  This maps to a
  949.  *    string hostname if possible, and prints out the message.
  950.  *
  951.  * Results:
  952.  *    None.
  953.  *
  954.  * Side effects:
  955.  *    printf.
  956.  *
  957.  *----------------------------------------------------------------------
  958.  */
  959.  
  960. void
  961. Net_HostPrint(spriteID, string)
  962.     int spriteID;
  963.     char *string;
  964. {
  965.     Sys_HostPrint(spriteID, string);
  966.     return;
  967. }
  968.  
  969. /*
  970.  *----------------------------------------------------------------------
  971.  *
  972.  * FillRouteInfo --
  973.  *
  974.  *    Converts from a Net_Route to a Net_RouteInfo. Net_RouteInfo
  975.  *     is the structure that is passed to user-level.
  976.  *
  977.  * Results:
  978.  *    None.
  979.  *
  980.  * Side effects:
  981.  *    None.
  982.  *
  983.  *----------------------------------------------------------------------
  984.  */
  985.  
  986. static void
  987. FillRouteInfo(routePtr, infoPtr)
  988.     Net_Route        *routePtr;     /* The route structure. */
  989.     Net_RouteInfo    *infoPtr;    /* The route info structure. */
  990. {
  991.     int        i;
  992.  
  993.     infoPtr->version = NET_ROUTE_VERSION;
  994.     infoPtr->spriteID = routePtr->spriteID;
  995.     infoPtr->protocol = routePtr->protocol;
  996.     infoPtr->interface = routePtr->interPtr->number;
  997.     infoPtr->netType = routePtr->interPtr->netType;
  998.     infoPtr->refCount = routePtr->refCount;
  999.     infoPtr->routeID = routePtr->routeID;
  1000.     infoPtr->flags = routePtr->flags;
  1001.     infoPtr->maxBytes = routePtr->maxBytes;
  1002.     infoPtr->minBytes = routePtr->minBytes;
  1003.     infoPtr->userData = routePtr->userData;
  1004.     for(i = 0; i < NET_MAX_PROTOCOLS; i++) {
  1005.     infoPtr->netAddress[i] = routePtr->netAddress[i];
  1006.     }
  1007.     strncpy(infoPtr->hostname, netHostInfo[routePtr->spriteID].name, 20);
  1008.     strncpy(infoPtr->machType, netHostInfo[routePtr->spriteID].machType, 12);
  1009.     strncpy(infoPtr->desc, routePtr->desc, 64);
  1010. }
  1011.  
  1012.